home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr07 / oleo130s.zip / OLEO130S.TAR / oleo-1.3 / io-edit.c < prev    next >
C/C++ Source or Header  |  1993-03-30  |  16KB  |  940 lines
  1. /*    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
  2.  
  3. This program is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 2, or (at your option)
  6. any later version.
  7.  
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. GNU General Public License for more details.
  12.  
  13. You should have received a copy of the GNU General Public License
  14. along with this software; see the file COPYING.  If not, write to
  15. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  16.  
  17.  
  18.  
  19.  
  20. #include "funcdef.h"
  21. #include <stdio.h>
  22. #include <fcntl.h>
  23. #include <errno.h>
  24. #include <ctype.h>
  25.  
  26. #undef NULL
  27.  
  28. #include "sysdef.h"
  29. #include "global.h"
  30. #include "cell.h"
  31. #include "io-utils.h"
  32. #include "io-edit.h"
  33. #include "io-abstract.h"
  34. #include "io-generic.h"
  35. #include "cmd.h"
  36. #include "format.h"
  37. #include "lists.h"
  38. #include "regions.h"
  39.  
  40.  
  41. /* Shorthand */
  42.  
  43. #define cursor        the_cmd_arg.cursor
  44. #define text         the_cmd_arg.text
  45. #define do_prompt    the_cmd_arg.do_prompt
  46. #define is_set        the_cmd_arg.is_set
  47. #define overwrite    the_cmd_arg.overwrite
  48.  
  49.  
  50.  
  51. /* Editting primitives
  52.  * 
  53.  * Commands that edit arguments to other commands should work by changing
  54.  * the string stored in the_cmd_arg.text.   These functions edit that string
  55.  * and correctly update the display.
  56.  */
  57.  
  58. #ifdef __STDC__
  59. int
  60. check_editting_mode (void)
  61. #else
  62. int
  63. check_editting_mode ()
  64. #endif
  65. {
  66.   if (!the_cmd_frame->cmd || cur_arg >= cmd_argc || !do_prompt || is_set)
  67.     {
  68.       io_error_msg ("Command '%s' is not appropriate now.",
  69.             cur_cmd->func_name);
  70.       /* not reached */
  71.     }
  72.   return 0;
  73. }
  74.  
  75. /* Set the currently-being-editted line. 
  76.  *
  77.  * When this function is called, it indicates that some argument
  78.  * is being read interactively from the user.  That fact is recorded
  79.  * in the command frame because it relevant to error handling.
  80.  * (See cmd_error in cmd.c)
  81.  *
  82.  */
  83. #ifdef __STDC__
  84. void
  85. begin_edit (void)
  86. #else
  87. void
  88. begin_edit ()
  89. #endif
  90. {
  91.   topclear = 0;
  92.   the_cmd_frame->complex_to_user = 1;
  93.   io_fix_input ();
  94. }
  95.  
  96. #ifdef __STDC__
  97. void
  98. setn_edit_line (char * str, int len)
  99. #else
  100. void
  101. setn_edit_line (str, len)
  102.      char * str;
  103.      int len;
  104. #endif
  105. {
  106.   setn_line (&text, str, len);
  107.   cursor = len;
  108. }
  109.  
  110. #ifdef __STDC__
  111. void
  112. toggle_overwrite (int set, int setting)
  113. #else
  114. void
  115. toggle_overwrite (set, setting)
  116.      int set;
  117.      int setting;
  118. #endif
  119. {
  120.   if (!set)
  121.     overwrite = !overwrite;
  122.   else
  123.     overwrite = (setting > 0);
  124. }
  125.  
  126. #ifdef __STDC__
  127. void
  128. beginning_of_line (void)
  129. #else
  130. void
  131. beginning_of_line ()
  132. #endif
  133. {
  134.   if (check_editting_mode ())
  135.     return;
  136.   cursor = 0;
  137.   io_move_cursor ();
  138. }
  139.  
  140.  
  141. #ifdef __STDC__
  142. void
  143. end_of_line (void)
  144. #else
  145. void
  146. end_of_line ()
  147. #endif
  148. {
  149.   if (check_editting_mode ())
  150.     return;
  151.   cursor = strlen (text.buf);
  152.   io_move_cursor ();
  153. }
  154.  
  155. #ifdef __STDC__
  156. void
  157. backward_char (int n)
  158. #else
  159. void
  160. backward_char (n)
  161.      int n;
  162. #endif
  163. {
  164.   if (check_editting_mode ())
  165.     return;
  166.   if (n < 0)
  167.     forward_char (-n);
  168.   else
  169.     {
  170.       char * error = 0;
  171.       if (cursor < n)
  172.     {
  173.       error = "Beginning of buffer.";
  174.       cursor = 0;
  175.     }
  176.       else
  177.     cursor -= n;
  178.       io_move_cursor ();
  179.       if (error)
  180.     io_error_msg (error);    /* Doesn't return. */
  181.     }
  182. }
  183.  
  184. #ifdef __STDC__
  185. void
  186. backward_word (int n)
  187. #else
  188. void
  189. backward_word (n)
  190. #endif
  191. {
  192.   if (check_editting_mode ())
  193.     return;
  194.   if (n < 0)
  195.     forward_word (-n);
  196.   else
  197.     {
  198.       if (cursor == strlen (text.buf))
  199.     --cursor;
  200.       while (n)
  201.     {
  202.       while (cursor
  203.          && !isalnum (text.buf[cursor]))
  204.         --cursor;
  205.       while (cursor
  206.          && isalnum (text.buf[cursor]))
  207.         --cursor;
  208.       --n;
  209.     }
  210.       io_move_cursor ();
  211.     }
  212. }
  213.  
  214.  
  215. #ifdef __STDC__
  216. void
  217. forward_char (int n)
  218. #else
  219. void
  220. forward_char (n)
  221.      int n;
  222. #endif
  223. {
  224.   if (check_editting_mode ())
  225.     return;
  226.   if (n < 0)
  227.     backward_char (-n);
  228.   else
  229.     {
  230.       char * error = 0;
  231.       int len = strlen(text.buf);
  232.       if ((cursor + n) >= len)
  233.     {
  234.       error = "End of buffer.";
  235.       cursor = len;
  236.     }
  237.       else
  238.     cursor += n;
  239.       io_move_cursor ();
  240.       if (error)
  241.     io_error_msg (error);    /* Doesn't return. */
  242.     }
  243. }
  244.  
  245.  
  246. #ifdef __STDC__
  247. void
  248. goto_char (int n)
  249. #else
  250. void
  251. goto_char (n)
  252.      int n;
  253. #endif
  254. {
  255.   if ((n < 0) || (n > (strlen (text.buf) + 1)))
  256.     io_error_msg ("Char out of range (%d)", n);
  257.   cursor = n;
  258.   io_move_cursor ();
  259. }
  260.  
  261. #ifdef __STDC__
  262. void
  263. forward_word (int n)
  264. #else
  265. void
  266. forward_word (n)
  267.      int n;
  268. #endif
  269. {
  270.   if (check_editting_mode ())
  271.     return;
  272.   if (n < 0)
  273.     backward_word (-n);
  274.   else
  275.     {
  276.       int len = strlen (text.buf);
  277.       while (n)
  278.     {
  279.       while ((cursor < len)
  280.          && !isalnum (text.buf[cursor]))
  281.         ++cursor;
  282.       while ((cursor < len)
  283.          && isalnum (text.buf[cursor]))
  284.         ++cursor;
  285.       --n;
  286.     }
  287.       io_move_cursor ();
  288.     }
  289. }
  290.  
  291.  
  292. #ifdef __STDC__
  293. static void
  294. erase (int len)
  295. #else
  296. static void
  297. erase (len)
  298.      int len;
  299. #endif
  300. {
  301.   if (check_editting_mode ())
  302.     return;
  303.   else
  304.     {
  305.       strcpy (&text.buf[cursor],
  306.           &text.buf[cursor + len]);
  307.       io_erase (len);
  308.     }
  309. }
  310.  
  311.  
  312. #ifdef __STDC__
  313. void
  314. backward_delete_char (int n)
  315. #else
  316. void
  317. backward_delete_char (n)
  318. #endif
  319. {
  320.   if (check_editting_mode ())
  321.     return;
  322.   if (n < 0)
  323.     delete_char (-n);
  324.   else
  325.     {
  326.       char * error = 0;
  327.       if (cursor < n)
  328.     {
  329.       error = "Beginning of buffer.";
  330.       n = cursor;
  331.     }
  332.       cursor -= n;
  333.       erase (n);
  334.       if (error)
  335.     io_error_msg (error);    /* Doesn't return. */
  336.     }
  337. }
  338.  
  339.  
  340. #ifdef __STDC__
  341. void 
  342. backward_delete_word (int n)
  343. #else
  344. void 
  345. backward_delete_word (n)
  346. #endif
  347. {
  348.   if (check_editting_mode ())
  349.     return;
  350.   else
  351.     {
  352.       int at = cursor;
  353.       while (n)
  354.     {
  355.       while (cursor
  356.          && !isalnum (text.buf[cursor]))
  357.         --cursor;
  358.  
  359.       while (cursor
  360.          && isalnum (text.buf[cursor - 1]))
  361.         --cursor;
  362.       --n;
  363.     }
  364.       erase (at - cursor);
  365.     }
  366. }
  367.  
  368.  
  369. #ifdef __STDC__
  370. void
  371. delete_to_start(void)
  372. #else
  373. void
  374. delete_to_start()
  375. #endif
  376. {
  377.   if (check_editting_mode ())
  378.     return;
  379.   else
  380.     {
  381.       int at = cursor;
  382.       cursor = 0;
  383.       erase (at);
  384.     }
  385. }
  386.  
  387.  
  388. #ifdef __STDC__
  389. void
  390. delete_char (int n)
  391. #else
  392. void
  393. delete_char (n)
  394.      int n;
  395. #endif
  396. {
  397.   if (check_editting_mode ())
  398.     return;
  399.   if (n < 0)
  400.     backward_delete_char (-n);
  401.   else
  402.     {
  403.       char * error = 0;
  404.       int len = strlen (text.buf);
  405.       if (cursor + n > len)
  406.     {
  407.       error = "End of buffer.";
  408.       n = len - cursor;
  409.     }
  410.       erase (n);
  411.       if (error)
  412.     io_error_msg (error);    /* Doesn't return. */
  413.     }
  414. }
  415.  
  416. #ifdef __STDC__
  417. void
  418. delete_word (int n)
  419. #else
  420. void
  421. delete_word (n)
  422.      int n;
  423. #endif
  424. {
  425.   if (check_editting_mode ())
  426.     return;
  427.   if (n < 0)
  428.     backward_delete_word (-n);
  429.   else
  430.     {
  431.       int len = strlen (text.buf);
  432.       int erase_len = 0;
  433.       while (n)
  434.     {
  435.       while (((cursor + erase_len) < len)
  436.          && !isalnum (text.buf[(cursor + erase_len)]))
  437.         ++erase_len;
  438.       while (((cursor + erase_len) < len)
  439.          && isalnum (text.buf[(cursor + erase_len)]))
  440.         ++erase_len;
  441.       --n;
  442.     }      
  443.       erase (erase_len);
  444.     }
  445. }
  446.  
  447.  
  448. #ifdef __STDC__
  449. void
  450. kill_line(void)
  451. #else
  452. void
  453. kill_line()
  454. #endif
  455. {
  456.   if (check_editting_mode ())
  457.     return;
  458.   else
  459.     {
  460.       int len = strlen (text.buf);
  461.       erase (len - cursor);
  462.     }
  463. }
  464.  
  465. #ifdef __STDC__
  466. void
  467. insert_string (char * str, int len)
  468. #else
  469. void
  470. insert_string (str, len)
  471.      char * str;
  472.      int len;
  473. #endif
  474. {
  475.   if (check_editting_mode ())
  476.     return;
  477.   splicen_line (&text, str, len, cursor);
  478.   io_insert (len);
  479.   cursor += len;
  480. }
  481.  
  482. #ifdef __STDC__
  483. void
  484. over_string (char * str, int len)
  485. #else
  486. void
  487. over_string (str, len)
  488.      char * str;
  489.      int len;
  490. #endif
  491. {
  492.   if (check_editting_mode ())
  493.     return;
  494.   if (cursor + len > strlen (text.buf))
  495.     {
  496.       catn_line (&text, str + text.alloc - cursor,
  497.          len - (text.alloc - cursor));
  498.       len = text.alloc - cursor;
  499.     }
  500.   bcopy (str, text.buf + cursor, len);
  501.   io_over (str, len);
  502.   cursor += len;
  503. }
  504.  
  505. #ifdef __STDC__
  506. void
  507. put_string (char * str, int len)
  508. #else
  509. void
  510. put_string (str, len)
  511.      char * str;
  512.      int len;
  513. #endif
  514. {
  515.   if (check_editting_mode ())
  516.     return;
  517.   (overwrite ? over_string : insert_string) (str, len);
  518. }
  519.  
  520.  
  521.  
  522. /* Higher Level editting commands. */
  523.  
  524. #ifdef __STDC__
  525. void
  526. insert_cell_expression (void)
  527. #else
  528. void
  529. insert_cell_expression ()
  530. #endif
  531. {
  532.   if (check_editting_mode ())
  533.     return;
  534.   else
  535.     {
  536.       CELL *cp;
  537.       char * in_str;
  538.       if (!(cp = find_cell (curow, cucol)))
  539.     return;
  540.       in_str = decomp (curow, cucol, cp);
  541.       put_string (in_str, strlen(in_str));
  542.       decomp_free ();
  543.     }
  544. }
  545.  
  546.  
  547. #ifdef __STDC__
  548. void
  549. insert_cell_value(void)
  550. #else
  551. void
  552. insert_cell_value()
  553. #endif
  554. {
  555.   if (check_editting_mode ())
  556.     return;
  557.   else
  558.     {
  559.       char * in_str;
  560.       in_str = cell_value_string (curow, cucol);
  561.       put_string (in_str, strlen(in_str));
  562.     }
  563. }
  564.  
  565. #ifdef __STDC__
  566. void
  567. insert_rel_ref(void)
  568. #else
  569. void
  570. insert_rel_ref()
  571. #endif
  572. {
  573.   if (check_editting_mode ())
  574.     return;
  575.   else
  576.     {
  577.       char vbuf[50];
  578.       char * in_str;
  579.       if (a0)
  580.     {
  581.       if (mkrow != NON_ROW)
  582.         {
  583.           struct rng r;
  584.           set_rng (&r, curow, cucol, mkrow, mkcol);
  585.           in_str = range_name (&r);
  586.         }
  587.       else
  588.         in_str = cell_name (curow, cucol);
  589.     }
  590.       else
  591.     {
  592.       if (mkrow != NON_ROW)
  593.         {
  594.           switch (((curow == setrow) << 3)
  595.               + ((mkrow == setrow) << 2)
  596.               + ((cucol == setcol) << 1)
  597.               + (mkcol == setcol))
  598.         {
  599.         case 0:
  600.         case 1:
  601.         case 2:
  602.         case 4:
  603.         case 5:
  604.         case 6:
  605.         case 8:
  606.         case 9:
  607.         case 10:
  608.           sprintf (vbuf, "r[%+d:%+d]c[%+d:%+d]",
  609.                (curow < mkrow ? curow : mkrow) - setrow,
  610.                (curow < mkrow ? mkrow : curow) - setrow,
  611.                (cucol < mkcol ? cucol : mkcol) - setcol,
  612.                (cucol < mkcol ? mkcol : cucol) - setcol);
  613.           break;
  614.           
  615.         case 3:
  616.         case 7:
  617.         case 11:
  618.           sprintf (vbuf, "r[%+d:%+d]c",
  619.                (curow < mkrow ? curow : mkrow) - setrow,
  620.                (curow < mkrow ? mkrow : curow) - setrow);
  621.           break;
  622.           
  623.         case 12:
  624.         case 14:
  625.         case 13:
  626.           sprintf (vbuf, "rc[%+d:%+d]",
  627.                (cucol < mkcol ? cucol : mkcol) - setcol,
  628.                (cucol < mkcol ? mkcol : cucol) - setcol);
  629.           break;
  630.           
  631.         case 15:
  632.           strcpy (vbuf, "rc");
  633.           break;
  634.         }
  635.         }
  636.       
  637.       else
  638.         {
  639.           switch (((curow == setrow) << 1) + (cucol == setcol))
  640.         {
  641.         case 0:
  642.           sprintf (vbuf, "r[%+d]c[%+d]", curow - setrow, cucol - setcol);
  643.           break;
  644.         case 1:
  645.           sprintf (vbuf, "r[%+d]c", curow - setrow);
  646.           break;
  647.         case 2:
  648.           sprintf (vbuf, "rc[%+d]", cucol - setcol);
  649.           break;
  650.         case 3:
  651.           strcpy (vbuf, "rc");
  652.           break;
  653. #ifdef TEST
  654.         default:
  655.           panic ("huh what");
  656. #endif
  657.         }
  658.         }
  659.       in_str = vbuf;
  660.     }
  661.       put_string (in_str, strlen (in_str));
  662.     }
  663. }
  664.  
  665.  
  666. #ifdef __STDC__
  667. void
  668. insert_abs_ref(void)
  669. #else
  670. void
  671. insert_abs_ref()
  672. #endif
  673. {
  674.   if (check_editting_mode ())
  675.     return;
  676.   else
  677.     {
  678.       char vbuf[50];
  679.       char * in_str;
  680.       /* Insert current cell/range name as an absolute reference */
  681.       if (a0)
  682.     {
  683.       if (mkrow != NON_ROW)
  684.         sprintf (vbuf, "$%s$%u:$%s:$%u",
  685.              col_to_str (cucol), curow, col_to_str (mkcol), mkrow) ;
  686.       else
  687.         sprintf (vbuf, "$%s$%u", col_to_str (cucol), curow);
  688.       in_str = vbuf;
  689.     }
  690.       else
  691.     {
  692.       if (mkrow != NON_ROW)
  693.         {
  694.           struct rng r;
  695.           
  696.           set_rng (&r, curow, cucol, mkrow, mkcol);
  697.           in_str = range_name (&r);
  698.         }
  699.       else
  700.         in_str = cell_name (curow, cucol);
  701.     }
  702.       put_string (in_str, strlen (in_str));  
  703.     }
  704. }
  705.  
  706. #ifdef __STDC__
  707. void
  708. insert_cell_attr (struct rng * rng, char * attr)
  709. #else
  710. void
  711. insert_cell_attr (rng, attr)
  712.      struct rng * rng;
  713.      char * attr;
  714. #endif
  715. {
  716.   struct line line;
  717.   init_line (&line);
  718.   if (!stricmp (attr, "width"))
  719.     {
  720.       int wid = get_nodef_width (rng->lc);
  721.       if (wid == 0)
  722.     set_line (&line, "def");
  723.       else
  724.     sprint_line (&line, "%d", wid - 1);
  725.     }
  726.   else if (!stricmp (attr, "height"))
  727.     {
  728.       int hgt = get_nodef_height (rng->lr);
  729.       if (hgt == 0)
  730.     set_line (&line, "def");
  731.       else
  732.     sprint_line (&line, "%d", hgt - 1);
  733.     }
  734.   else if (!stricmp (attr, "format"))
  735.     {
  736.       CELL * cp = find_cell (rng->lr, rng->lc);
  737.       if (!cp)
  738.     set_line (&line, "def");
  739.       else
  740.     {
  741.       int fmt = GET_FMT (cp);
  742.       set_line (&line, fmt_to_str (fmt));
  743.     }
  744.     }
  745.   else if (!stricmp (attr, "font"))
  746.     {
  747.       CELL * cp = find_cell (rng->lr, rng->lc);
  748.       if (!(cp && cp->cell_font))
  749.     set_line (&line, "def");
  750.       else
  751.     set_line (&line, cp->cell_font->names->oleo_name);
  752.     }
  753.   else if (!stricmp (attr, "font-scale"))
  754.     {
  755.       CELL * cp = find_cell (rng->lr, rng->lc);
  756.       if (!(cp && cp->cell_font))
  757.     set_line (&line, "1.0");
  758.       else
  759.     sprint_line (&line, "%lf", cp->cell_font->scale);
  760.     }
  761.   put_string (line.buf, strlen (line.buf));
  762. }
  763.  
  764. #ifdef __STDC__
  765. void
  766. insert_usr_fmt_part (int fmt, int stat)
  767. #else
  768. void
  769. insert_usr_fmt_part (fmt, stat)
  770.      int fmt;
  771.      int stat;
  772. #endif
  773. {
  774.   char * usr_stats[9];
  775.   if ((fmt < 1) || (fmt > 16))
  776.     io_error_msg
  777.       ("insert-user-format-part arg 1 out of range (%d); should be in [1-16].",
  778.        fmt);
  779.   --fmt;
  780.   if ((stat < 1) || (stat > 16))
  781.     io_error_msg
  782.       ("insert-user-format-part arg 2 out of range (%d); should be in [1-9].",
  783.        stat);
  784.   --stat;
  785.   get_usr_stats (fmt, usr_stats);
  786.   put_string (usr_stats[stat], strlen (usr_stats[stat]));
  787. }
  788.  
  789. #ifdef __STDC__
  790. void
  791. self_insert_command (int ch, int count)
  792. #else
  793. void
  794. self_insert_command (ch, count)
  795.      int ch;
  796.      int count;
  797. #endif
  798. {
  799.   if (check_editting_mode ())
  800.     return;
  801.   else if (count == 1)
  802.     {
  803.       char chr = ch;
  804.       put_string (&chr, 1);
  805.     }
  806.   else if (count > 0)
  807.     {
  808.       char * buf = (char *)ck_malloc (count); /* sleazy, huh? */
  809.       int x;
  810.       for (x = 0; x < count; ++x)
  811.     buf[x] = ch;
  812.       put_string (buf, count);
  813.     }
  814. }
  815.  
  816.  
  817. /* Keysequences are read using the `keyseq' keymap.
  818.  * Every key in that map should be bound to this function.
  819.  */
  820. #ifdef __STDC__
  821. void
  822. self_map_command (int c)
  823. #else
  824. void
  825. self_map_command (c)
  826.      int c;
  827. #endif
  828. {
  829.   struct keymap * map = the_maps[the_cmd_arg.val.key.cmd.code];
  830.   char space = ' ';
  831.   char * str = char_to_string (c);
  832.  
  833.   insert_string (str, strlen (str));
  834.   insert_string (&space, 1);
  835.  
  836.   while (map)
  837.     {
  838.       the_cmd_arg.val.key.cmd = map->keys[c];
  839.       if (the_cmd_arg.val.key.cmd.vector < 0)
  840.     {
  841.       if (the_cmd_arg.val.key.cmd.code < 0)
  842.         map = map->map_next;
  843.       else
  844.         return;
  845.     }
  846.       else
  847.     break;
  848.     }
  849.   exit_minibuffer ();
  850.   return;
  851. }
  852.  
  853. #ifdef __STDC__
  854. void
  855. insert_current_filename (void)
  856. #else
  857. void
  858. insert_current_filename ()
  859. #endif
  860. {
  861.   if (current_filename)
  862.     put_string (current_filename, strlen (current_filename));
  863. }
  864.  
  865.  
  866. /* Reading a single character is done with the read-char
  867.  * map.  Every key in that map should be bound to this function.
  868.  */
  869. #ifdef __STDC__
  870. void
  871. exit_self_inserting (int c)
  872. #else
  873. void
  874. exit_self_inserting (c)
  875.      int c;
  876. #endif
  877. {
  878.   char * str = char_to_string (c);
  879.  
  880.   insert_string (str, strlen (str));
  881.   exit_minibuffer ();
  882. }
  883.  
  884.  
  885. #ifdef __STDC__
  886. static int
  887. issymb (int c)
  888. #else
  889. static int
  890. issymb (c)
  891.      int c;
  892. #endif
  893. {
  894.   return isalpha (c) || isdigit (c) || (c == '_');
  895. }
  896.  
  897. #undef text
  898. #undef cursor
  899. #undef do_prompt
  900. #ifdef __STDC__
  901. void
  902. insert_context_word (void)
  903. #else
  904. void
  905. insert_context_word ()
  906. #endif
  907. {
  908.   struct command_frame * cf = the_cmd_frame->prev;
  909.   if (   (cf == the_cmd_frame)
  910.       || !cf->cmd
  911.       || !cf->argv [cf->_cur_arg].do_prompt)
  912.     return;
  913.   {
  914.     struct command_arg * ca = &cf->argv [cf->_cur_arg];
  915.     char * beg_text = ca->text.buf;
  916.     char * last = beg_text + ca->cursor;
  917.     char * start;
  918.  
  919.     while ((last > beg_text) && !issymb(*last))
  920.       --last;
  921.     while (*last && issymb (*last))
  922.       ++last;
  923.     --last;
  924.     start = last;
  925.     while ((start > beg_text) && issymb(*start))
  926.       --start;
  927.     if (!issymb (*start) && (start < last))
  928.       ++start;
  929.  
  930.     if ((start <= last) && issymb (*start))
  931.       {
  932.     insert_string (start, last - start + 1);
  933.     the_cmd_arg.cursor = 0;
  934.       }
  935.   }
  936. }
  937. #define text the_cmd_arg.text
  938. #define do_prompt the_cmd_arg.do_prompt
  939. #define cursor the_cmd_arg.cursor
  940.